home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / out-of-phase-102-c / OutOfPhase 1.02 Source / OutOfPhase Folder / InstrWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  21.5 KB  |  718 lines  |  [TEXT/KAHL]
  1. /* InstrWindow.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "InstrWindow.h"
  31. #include "InstrObject.h"
  32. #include "MainWindowStuff.h"
  33. #include "InstrList.h"
  34. #include "TextEdit.h"
  35. #include "WindowDispatcher.h"
  36. #include "Memory.h"
  37. #include "GrowIcon.h"
  38. #include "Main.h"
  39. #include "FindDialog.h"
  40. #include "DataMunging.h"
  41. #include "GlobalWindowMenuList.h"
  42.  
  43.  
  44. #define WINSIZEX (490)
  45. #define WINSIZEY (320)
  46. #define TITLEINDENT (8)
  47.  
  48. #define NAMEX(W,H) (-1)
  49. #define NAMEY(W,H) (2)
  50. #define NAMEWIDTH(W,H) (W + 2)
  51. #define NAMEHEIGHT(W,H) (40)
  52.  
  53. #define BODYX(W,H) (NAMEX(W,H))
  54. #define BODYY(W,H) (NAMEY(W,H) + NAMEHEIGHT(W,H) + 4)
  55. #define BODYWIDTH(W,H) (NAMEWIDTH(W,H))
  56. #define BODYHEIGHT(W,H) (H - BODYY(W,H) + 1)
  57.  
  58.  
  59. struct InstrWindowRec
  60.     {
  61.         InstrObjectRec*            InstrObj;
  62.         MainWindowRec*            MainWindow;
  63.         InstrListRec*                InstrList;
  64.  
  65.         WinType*                        ScreenID;
  66.         TextEditRec*                NameEdit;
  67.         TextEditRec*                BodyEdit;
  68.         TextEditRec*                ActiveTextEdit;
  69.         GenericWindowRec*        MyGenericWindow; /* how the window event dispatcher knows us */
  70.         MenuItemType*                MyMenuItem;
  71.     };
  72.  
  73.  
  74. /* create a new instrument specification editing window */
  75. InstrWindowRec*            NewInstrWindow(struct InstrObjectRec* InstrObj,
  76.                                             struct MainWindowRec* MainWindow,
  77.                                             struct InstrListRec* InstrList, short WinX, short WinY,
  78.                                             short WinWidth, short WinHeight)
  79.     {
  80.         InstrWindowRec*        Window;
  81.         OrdType                        FontHeight;
  82.         char*                            StringTemp;
  83.  
  84.         /* deal with window placement */
  85.         if ((WinWidth < 100) || (WinHeight < 100) || ((eOptionKey & CheckModifiers()) != 0))
  86.             {
  87.                 WinX = 20 + WindowOtherEdgeWidths(eDocumentWindow);
  88.                 WinY = 20 + WindowTitleBarHeight(eDocumentWindow);
  89.                 WinWidth = WINSIZEX;
  90.                 WinHeight = WINSIZEY;
  91.             }
  92.         MakeWindowFitOnScreen(&WinX,&WinY,&WinWidth,&WinHeight);
  93.  
  94.         CheckPtrExistence(InstrObj);
  95.         CheckPtrExistence(MainWindow);
  96.         CheckPtrExistence(InstrList);
  97.         Window = (InstrWindowRec*)AllocPtrCanFail(sizeof(InstrWindowRec),"InstrWindowRec");
  98.         if (Window == NIL)
  99.             {
  100.              FailurePoint1:
  101.                 return NIL;
  102.             }
  103.         Window->InstrObj = InstrObj;
  104.         Window->MainWindow = MainWindow;
  105.         Window->InstrList = InstrList;
  106.  
  107.         Window->ScreenID = MakeNewWindow(eDocumentWindow,eWindowClosable,
  108.             eWindowZoomable,eWindowResizable,WinX,WinY,WinWidth,WinHeight,
  109.             (void (*)(void*))&InstrWindowUpdate,Window);
  110.         if (Window->ScreenID == 0)
  111.             {
  112.              FailurePoint2:
  113.                 ReleasePtr((char*)Window);
  114.                 goto FailurePoint1;
  115.             }
  116.         FontHeight = GetFontHeight(GetScreenFont(),9);
  117.  
  118.         Window->NameEdit = NewTextEdit(Window->ScreenID,eTENoScrollBars,GetScreenFont(),9,
  119.             NAMEX(WinWidth,WinHeight),NAMEY(WinWidth,WinHeight) + FontHeight,
  120.             NAMEWIDTH(WinWidth,WinHeight),NAMEHEIGHT(WinWidth,WinHeight) - FontHeight);
  121.         if (Window->NameEdit == NIL)
  122.             {
  123.              FailurePoint3:
  124.                 KillWindow(Window->ScreenID);
  125.                 goto FailurePoint2;
  126.             }
  127.         StringTemp = InstrObjectGetNameCopy(InstrObj);
  128.         if (StringTemp == NIL)
  129.             {
  130.              FailurePoint4:
  131.                 DisposeTextEdit(Window->NameEdit);
  132.                 goto FailurePoint3;
  133.             }
  134.         TextEditNewRawData(Window->NameEdit,StringTemp,"\x0a");
  135.         ReleasePtr(StringTemp);
  136.         TextEditHasBeenSaved(Window->NameEdit);
  137.  
  138.         Window->BodyEdit = NewTextEdit(Window->ScreenID,
  139.             (TEScrollType)(eTEVScrollBar | eTEHScrollBar),GetMonospacedFont(),9,
  140.             BODYX(WinWidth,WinHeight),BODYY(WinWidth,WinHeight) + FontHeight,
  141.             BODYWIDTH(WinWidth,WinHeight),BODYHEIGHT(WinWidth,WinHeight) - FontHeight);
  142.         if (Window->BodyEdit == NIL)
  143.             {
  144.              FailurePoint5:
  145.                 goto FailurePoint4;
  146.             }
  147.         StringTemp = InstrObjectGetDefinitionCopy(InstrObj);
  148.         if (StringTemp == NIL)
  149.             {
  150.              FailurePoint6:
  151.                 DisposeTextEdit(Window->BodyEdit);
  152.                 goto FailurePoint5;
  153.             }
  154.         SetTextEditTabSize(Window->BodyEdit,MainWindowGetTabSize(MainWindow));
  155.         TextEditNewRawData(Window->BodyEdit,StringTemp,"\x0a");
  156.         ReleasePtr(StringTemp);
  157.         TextEditHasBeenSaved(Window->BodyEdit);
  158.         SetTextEditAutoIndent(Window->BodyEdit,True);
  159.         Window->ActiveTextEdit = Window->BodyEdit;
  160.  
  161.         Window->MyGenericWindow = CheckInNewWindow(Window->ScreenID,Window,
  162.             (void (*)(void*,MyBoolean,OrdType,OrdType,ModifierFlags))&InstrWindowDoIdle,
  163.             (void (*)(void*))&InstrWindowBecomeActive,
  164.             (void (*)(void*))&InstrWindowBecomeInactive,
  165.             (void (*)(void*))&InstrWindowResized,
  166.             (void (*)(OrdType,OrdType,ModifierFlags,void*))&InstrWindowDoMouseDown,
  167.             (void (*)(unsigned char,ModifierFlags,void*))&InstrWindowDoKeyDown,
  168.             (void (*)(void*))&InstrWindowClose,
  169.             (void (*)(void*))&InstrWindowMenuSetup,
  170.             (void (*)(void*,MenuItemType*))&InstrWindowDoMenuCommand);
  171.         if (Window->MyGenericWindow == NIL)
  172.             {
  173.              FailurePoint7:
  174.                 goto FailurePoint6;
  175.             }
  176.  
  177.         Window->MyMenuItem = MakeNewMenuItem(mmWindowMenu,"x",0);
  178.         if (Window->MyMenuItem == NIL)
  179.             {
  180.              FailurePoint8:
  181.                 CheckOutDyingWindow(Window->MyGenericWindow);
  182.                 goto FailurePoint7;
  183.             }
  184.         if (!RegisterWindowMenuItem(Window->MyMenuItem,(void (*)(void*))&ActivateThisWindow,
  185.             Window->ScreenID))
  186.             {
  187.              FailurePoint9:
  188.                 KillMenuItem(Window->MyMenuItem);
  189.                 goto FailurePoint8;
  190.             }
  191.  
  192.         InstrWindowResetTitlebar(Window);
  193.  
  194.         return Window;
  195.     }
  196.  
  197.  
  198. /* write back modified data and dispose of the instrument window */
  199. void                                DisposeInstrWindow(InstrWindowRec* Window)
  200.     {
  201.         CheckPtrExistence(Window);
  202.  
  203.         /* save data */
  204.         if (!InstrWindowWritebackModifiedData(Window))
  205.             {
  206.                 /* failed -- now what? */
  207.             }
  208.  
  209.         CheckOutDyingWindow(Window->MyGenericWindow);
  210.         InstrObjectWindowCloseNotify(Window->InstrObj,
  211.             GetWindowXStart(Window->ScreenID),GetWindowYStart(Window->ScreenID),
  212.             GetWindowWidth(Window->ScreenID),GetWindowHeight(Window->ScreenID));
  213.         DeregisterWindowMenuItem(Window->MyMenuItem);
  214.         KillMenuItem(Window->MyMenuItem);
  215.         DisposeTextEdit(Window->NameEdit);
  216.         DisposeTextEdit(Window->BodyEdit);
  217.         KillWindow(Window->ScreenID);
  218.         ReleasePtr((char*)Window);
  219.     }
  220.  
  221.  
  222. /* bring the window to the top and give it the focus */
  223. void                                BringInstrWindowToFront(InstrWindowRec* Window)
  224.     {
  225.         CheckPtrExistence(Window);
  226.         ActivateThisWindow(Window->ScreenID);
  227.     }
  228.  
  229.  
  230. /* returns True if the data has been modified since the last file save. */
  231. MyBoolean                        HasInstrWindowBeenModified(InstrWindowRec* Window)
  232.     {
  233.         CheckPtrExistence(Window);
  234.         return TextEditDoesItNeedToBeSaved(Window->NameEdit)
  235.             || TextEditDoesItNeedToBeSaved(Window->BodyEdit);
  236.     }
  237.  
  238.  
  239. /* highlight the line in the instrument specification edit */
  240. void                                InstrWindowHilightLine(InstrWindowRec* Window, long LineNumber)
  241.     {
  242.         CheckPtrExistence(Window);
  243.         if (Window->ActiveTextEdit != Window->BodyEdit)
  244.             {
  245.                 DisableTextEditSelection(Window->ActiveTextEdit);
  246.                 Window->ActiveTextEdit = Window->BodyEdit;
  247.                 EnableTextEditSelection(Window->ActiveTextEdit);
  248.             }
  249.         SetTextEditSelection(Window->BodyEdit,LineNumber,0,LineNumber + 1,0);
  250.         TextEditShowSelection(Window->BodyEdit);
  251.     }
  252.  
  253.  
  254. void                                InstrWindowDoIdle(InstrWindowRec* Window, MyBoolean CheckCursorFlag,
  255.                                             OrdType XLoc, OrdType YLoc, ModifierFlags Modifiers)
  256.     {
  257.         CheckPtrExistence(Window);
  258.         TextEditUpdateCursor(Window->ActiveTextEdit);
  259.         if (CheckCursorFlag)
  260.             {
  261.                 if (TextEditIBeamTest(Window->NameEdit,XLoc,YLoc)
  262.                     || TextEditIBeamTest(Window->BodyEdit,XLoc,YLoc))
  263.                     {
  264.                         SetIBeamCursor();
  265.                     }
  266.                  else
  267.                     {
  268.                         SetArrowCursor();
  269.                     }
  270.             }
  271.     }
  272.  
  273.  
  274. void                                InstrWindowBecomeActive(InstrWindowRec* Window)
  275.     {
  276.         OrdType                        XSize;
  277.         OrdType                        YSize;
  278.  
  279.         CheckPtrExistence(Window);
  280.         EnableTextEditSelection(Window->ActiveTextEdit);
  281.         XSize = GetWindowWidth(Window->ScreenID);
  282.         YSize = GetWindowHeight(Window->ScreenID);
  283.         SetClipRect(Window->ScreenID,XSize - 15,YSize - 15,XSize,YSize);
  284.         DrawBitmap(Window->ScreenID,XSize-15,YSize-15,GetGrowIcon(True/*enablegrowicon*/));
  285.     }
  286.  
  287.  
  288. void                                InstrWindowBecomeInactive(InstrWindowRec* Window)
  289.     {
  290.         OrdType                        XSize;
  291.         OrdType                        YSize;
  292.  
  293.         CheckPtrExistence(Window);
  294.         DisableTextEditSelection(Window->ActiveTextEdit);
  295.         XSize = GetWindowWidth(Window->ScreenID);
  296.         YSize = GetWindowHeight(Window->ScreenID);
  297.         SetClipRect(Window->ScreenID,XSize - 15,YSize - 15,XSize,YSize);
  298.         DrawBitmap(Window->ScreenID,XSize-15,YSize-15,GetGrowIcon(False/*disablegrowicon*/));
  299.     }
  300.  
  301.  
  302. void                                InstrWindowResized(InstrWindowRec* Window)
  303.     {
  304.         OrdType                        XSize;
  305.         OrdType                        YSize;
  306.         OrdType                        FontHeight;
  307.  
  308.         CheckPtrExistence(Window);
  309.         XSize = GetWindowWidth(Window->ScreenID);
  310.         YSize = GetWindowHeight(Window->ScreenID);
  311.         SetClipRect(Window->ScreenID,0,0,XSize,YSize);
  312.         DrawBoxErase(Window->ScreenID,0,0,XSize,YSize);
  313.         FontHeight = GetFontHeight(GetScreenFont(),9);
  314.         SetTextEditPosition(Window->NameEdit,
  315.             NAMEX(XSize,YSize),NAMEY(XSize,YSize) + FontHeight,
  316.             NAMEWIDTH(XSize,YSize),NAMEHEIGHT(XSize,YSize) - FontHeight);
  317.         SetTextEditPosition(Window->BodyEdit,
  318.             BODYX(XSize,YSize),BODYY(XSize,YSize) + FontHeight,
  319.             BODYWIDTH(XSize,YSize),BODYHEIGHT(XSize,YSize) - FontHeight);
  320.     }
  321.  
  322.  
  323. void                                InstrWindowDoMouseDown(OrdType XLoc, OrdType YLoc,
  324.                                             ModifierFlags Modifiers, InstrWindowRec* Window)
  325.     {
  326.         CheckPtrExistence(Window);
  327.         if ((XLoc >= GetWindowWidth(Window->ScreenID) - 15)
  328.             && (XLoc < GetWindowWidth(Window->ScreenID))
  329.             && (YLoc >= GetWindowHeight(Window->ScreenID) - 15)
  330.             && (YLoc < GetWindowHeight(Window->ScreenID)))
  331.             {
  332.                 UserGrowWindow(Window->ScreenID,XLoc,YLoc);
  333.                 InstrWindowResized(Window);
  334.             }
  335.         else if (TextEditHitTest(Window->NameEdit,XLoc,YLoc))
  336.             {
  337.                 if (Window->ActiveTextEdit != Window->NameEdit)
  338.                     {
  339.                         DisableTextEditSelection(Window->ActiveTextEdit);
  340.                         Window->ActiveTextEdit = Window->NameEdit;
  341.                         EnableTextEditSelection(Window->ActiveTextEdit);
  342.                     }
  343.                 TextEditDoMouseDown(Window->NameEdit,XLoc,YLoc,Modifiers);
  344.             }
  345.         else if (TextEditHitTest(Window->BodyEdit,XLoc,YLoc))
  346.             {
  347.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  348.                     {
  349.                         DisableTextEditSelection(Window->ActiveTextEdit);
  350.                         Window->ActiveTextEdit = Window->BodyEdit;
  351.                         EnableTextEditSelection(Window->ActiveTextEdit);
  352.                     }
  353.                 TextEditDoMouseDown(Window->BodyEdit,XLoc,YLoc,Modifiers);
  354.             }
  355.     }
  356.  
  357.  
  358. void                                InstrWindowDoKeyDown(unsigned char KeyCode,
  359.                                             ModifierFlags Modifiers, InstrWindowRec* Window)
  360.     {
  361.         CheckPtrExistence(Window);
  362.         TextEditDoKeyPressed(Window->ActiveTextEdit,KeyCode,Modifiers);
  363.     }
  364.  
  365.  
  366. void                                InstrWindowClose(InstrWindowRec* Window)
  367.     {
  368.         DisposeInstrWindow(Window);
  369.     }
  370.  
  371.  
  372. void                                InstrWindowMenuSetup(InstrWindowRec* Window)
  373.     {
  374.         CheckPtrExistence(Window);
  375.         MainWindowEnableGlobalMenus(Window->MainWindow);
  376.         EnableMenuItem(mPaste);
  377.         ChangeItemName(mPaste,"Paste Text");
  378.         if (TextEditIsThereValidSelection(Window->ActiveTextEdit))
  379.             {
  380.                 EnableMenuItem(mCut);
  381.                 ChangeItemName(mCut,"Cut Text");
  382.                 EnableMenuItem(mCopy);
  383.                 ChangeItemName(mCopy,"Copy Text");
  384.                 EnableMenuItem(mClear);
  385.                 ChangeItemName(mClear,"Clear Text");
  386.             }
  387.         EnableMenuItem(mShiftLeft);
  388.         EnableMenuItem(mShiftRight);
  389.         EnableMenuItem(mBalanceParens);
  390.         EnableMenuItem(mSelectAll);
  391.         ChangeItemName(mSelectAll,"Select All Text");
  392.         if (TextEditCanWeUndo(Window->ActiveTextEdit))
  393.             {
  394.                 EnableMenuItem(mUndo);
  395.                 ChangeItemName(mUndo,"Undo Text Change");
  396.             }
  397.         ChangeItemName(mCloseFile,"Close Instrument Editor");
  398.         EnableMenuItem(mCloseFile);
  399.         ChangeItemName(mDeleteObject,"Delete Instrument");
  400.         EnableMenuItem(mDeleteObject);
  401.         EnableMenuItem(mFind);
  402.         if (PtrSize(GlobalSearchString) != 0)
  403.             {
  404.                 EnableMenuItem(mFindAgain);
  405.                 if ((Window->ActiveTextEdit != NIL)
  406.                     && TextEditIsThereValidSelection(Window->ActiveTextEdit))
  407.                     {
  408.                         EnableMenuItem(mReplace);
  409.                         EnableMenuItem(mReplaceAndFindAgain);
  410.                     }
  411.             }
  412.         EnableMenuItem(mShowSelection);
  413.         if ((Window->ActiveTextEdit != NIL)
  414.             && TextEditIsThereValidSelection(Window->ActiveTextEdit))
  415.             {
  416.                 EnableMenuItem(mEnterSelection);
  417.             }
  418.         SetItemCheckmark(Window->MyMenuItem);
  419.         EnableMenuItem(mBuildFunction);
  420.         ChangeItemName(mBuildFunction,"Build Instrument");
  421.         EnableMenuItem(mUnbuildFunction);
  422.         ChangeItemName(mUnbuildFunction,"Unbuild Instrument");
  423.     }
  424.  
  425.  
  426. void                                InstrWindowDoMenuCommand(InstrWindowRec* Window,
  427.                                             struct MenuItemType* MenuItem)
  428.     {
  429.         CheckPtrExistence(Window);
  430.         if (MainWindowDoGlobalMenuItem(Window->MainWindow,MenuItem))
  431.             {
  432.             }
  433.         else if (MenuItem == mPaste)
  434.             {
  435.                 TextEditDoMenuPaste(Window->ActiveTextEdit);
  436.             }
  437.         else if (MenuItem == mCut)
  438.             {
  439.                 TextEditDoMenuCut(Window->ActiveTextEdit);
  440.             }
  441.         else if (MenuItem == mCopy)
  442.             {
  443.                 TextEditDoMenuCopy(Window->ActiveTextEdit);
  444.             }
  445.         else if (MenuItem == mClear)
  446.             {
  447.                 TextEditDoMenuClear(Window->ActiveTextEdit);
  448.             }
  449.         else if (MenuItem == mSelectAll)
  450.             {
  451.                 TextEditDoMenuSelectAll(Window->ActiveTextEdit);
  452.             }
  453.         else if (MenuItem == mUndo)
  454.             {
  455.                 TextEditDoMenuUndo(Window->ActiveTextEdit);
  456.             }
  457.         else if (MenuItem == mCloseFile)
  458.             {
  459.                 InstrWindowClose(Window);
  460.             }
  461.         else if (MenuItem == mShiftLeft)
  462.             {
  463.                 TextEditShiftSelectionLeftOneTab(Window->ActiveTextEdit);
  464.             }
  465.         else if (MenuItem == mShiftRight)
  466.             {
  467.                 TextEditShiftSelectionRightOneTab(Window->ActiveTextEdit);
  468.             }
  469.         else if (MenuItem == mBalanceParens)
  470.             {
  471.                 TextEditBalanceParens(Window->ActiveTextEdit);
  472.             }
  473.         else if (MenuItem == mDeleteObject)
  474.             {
  475.                 InstrListDeleteInstr(Window->InstrList,Window->InstrObj);
  476.             }
  477.         else if (MenuItem == mFind)
  478.             {
  479.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  480.                     {
  481.                         DisableTextEditSelection(Window->ActiveTextEdit);
  482.                         Window->ActiveTextEdit = Window->BodyEdit;
  483.                         EnableTextEditSelection(Window->ActiveTextEdit);
  484.                     }
  485.                 switch (DoFindDialog(&GlobalSearchString,&GlobalReplaceString,
  486.                     mCut,mPaste,mCopy,mUndo,mSelectAll,mClear))
  487.                     {
  488.                         default:
  489.                             EXECUTE(PRERR(ForceAbort,
  490.                                 "FunctionWindowDoMenuCommand:  bad value from DoFindDialog"));
  491.                             break;
  492.                         case eFindCancel:
  493.                         case eDontFind:
  494.                             break;
  495.                         case eFindFromStart:
  496.                             SetTextEditInsertionPoint(Window->ActiveTextEdit,0,0);
  497.                             TextEditFindAgain(Window->ActiveTextEdit,GlobalSearchString);
  498.                             TextEditShowSelection(Window->ActiveTextEdit);
  499.                             break;
  500.                         case eFindAgain:
  501.                             TextEditFindAgain(Window->ActiveTextEdit,GlobalSearchString);
  502.                             TextEditShowSelection(Window->ActiveTextEdit);
  503.                             break;
  504.                     }
  505.             }
  506.         else if (MenuItem == mFindAgain)
  507.             {
  508.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  509.                     {
  510.                         DisableTextEditSelection(Window->ActiveTextEdit);
  511.                         Window->ActiveTextEdit = Window->BodyEdit;
  512.                         EnableTextEditSelection(Window->ActiveTextEdit);
  513.                     }
  514.                 TextEditFindAgain(Window->ActiveTextEdit,GlobalSearchString);
  515.                 TextEditShowSelection(Window->ActiveTextEdit);
  516.             }
  517.         else if (MenuItem == mReplace)
  518.             {
  519.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  520.                     {
  521.                         DisableTextEditSelection(Window->ActiveTextEdit);
  522.                         Window->ActiveTextEdit = Window->BodyEdit;
  523.                         EnableTextEditSelection(Window->ActiveTextEdit);
  524.                     }
  525.                 if (TextEditIsThereValidSelection(Window->ActiveTextEdit))
  526.                     {
  527.                         TextEditInsertRawData(Window->ActiveTextEdit,GlobalReplaceString,
  528.                             SYSTEMLINEFEED);
  529.                     }
  530.             }
  531.         else if (MenuItem == mReplaceAndFindAgain)
  532.             {
  533.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  534.                     {
  535.                         DisableTextEditSelection(Window->ActiveTextEdit);
  536.                         Window->ActiveTextEdit = Window->BodyEdit;
  537.                         EnableTextEditSelection(Window->ActiveTextEdit);
  538.                     }
  539.                 if (TextEditIsThereValidSelection(Window->ActiveTextEdit))
  540.                     {
  541.                         TextEditInsertRawData(Window->ActiveTextEdit,GlobalReplaceString,
  542.                             SYSTEMLINEFEED);
  543.                         TextEditFindAgain(Window->ActiveTextEdit,GlobalSearchString);
  544.                         TextEditShowSelection(Window->ActiveTextEdit);
  545.                     }
  546.             }
  547.         else if (MenuItem == mShowSelection)
  548.             {
  549.                 TextEditShowSelection(Window->ActiveTextEdit);
  550.             }
  551.         else if (MenuItem == mEnterSelection)
  552.             {
  553.                 char*                        NewString;
  554.  
  555.                 NewString = TextEditGetSelection(Window->ActiveTextEdit);
  556.                 if (NewString != NIL)
  557.                     {
  558.                         ReleasePtr(GlobalSearchString);
  559.                         GlobalSearchString = NewString;
  560.                     }
  561.             }
  562.         else if (MenuItem == mBuildFunction)
  563.             {
  564.                 BuildInstrObject(Window->InstrObj);
  565.             }
  566.         else if (MenuItem == mUnbuildFunction)
  567.             {
  568.                 UnbuildInstrObject(Window->InstrObj);
  569.             }
  570.         else
  571.             {
  572.                 EXECUTE(PRERR(AllowResume,"FunctionWindowDoMenuCommand:  unknown menu command"));
  573.             }
  574.     }
  575.  
  576.  
  577. void                                InstrWindowUpdate(InstrWindowRec* Window)
  578.     {
  579.         OrdType                        XSize;
  580.         OrdType                        YSize;
  581.  
  582.         CheckPtrExistence(Window);
  583.         TextEditFullRedraw(Window->NameEdit);
  584.         TextEditFullRedraw(Window->BodyEdit);
  585.         XSize = GetWindowWidth(Window->ScreenID);
  586.         YSize = GetWindowHeight(Window->ScreenID);
  587.         SetClipRect(Window->ScreenID,0,0,XSize,YSize);
  588.         DrawTextLine(Window->ScreenID,GetScreenFont(),9,"Instrument Name:",16,
  589.             NAMEX(XSize,YSize) + TITLEINDENT,NAMEY(XSize,YSize),eBold);
  590.         DrawTextLine(Window->ScreenID,GetScreenFont(),9,"Instrument Body:",16,
  591.             BODYX(XSize,YSize) + TITLEINDENT,BODYY(XSize,YSize),eBold);
  592.         SetClipRect(Window->ScreenID,XSize - 15,YSize - 15,XSize,YSize);
  593.         DrawBitmap(Window->ScreenID,XSize - 15,YSize - 15,
  594.             GetGrowIcon(Window->MyGenericWindow == GetCurrentWindowID()));
  595.     }
  596.  
  597.  
  598. /* get a copy of the instrument name */
  599. char*                                InstrWindowGetNameCopy(InstrWindowRec* Window)
  600.     {
  601.         CheckPtrExistence(Window);
  602.         return TextEditGetRawData(Window->NameEdit,"\x0a");
  603.     }
  604.  
  605.  
  606. /* get a copy of the instrument definition text */
  607. char*                                InstrWindowGetDefinitionCopy(InstrWindowRec* Window)
  608.     {
  609.         CheckPtrExistence(Window);
  610.         return TextEditGetRawData(Window->BodyEdit,"\x0a");
  611.     }
  612.  
  613.  
  614. /* the filename has changed, so update the window title bar.  NewFilename is a */
  615. /* non-null-terminated string which must be disposed by the caller. */
  616. void                                InstrWindowGlobalNameChange(InstrWindowRec* Window, char* NewFilename)
  617.     {
  618.         char*                            LocalNameCopy;
  619.  
  620.         CheckPtrExistence(Window);
  621.         CheckPtrExistence(NewFilename);
  622.         LocalNameCopy = InstrWindowGetNameCopy(Window);
  623.         if (LocalNameCopy != NIL)
  624.             {
  625.                 char*                            SeparatorString;
  626.  
  627.                 SeparatorString = StringToBlockCopy(":  ");
  628.                 if (SeparatorString != NIL)
  629.                     {
  630.                         char*                            LeftHalfOfString;
  631.  
  632.                         LeftHalfOfString = ConcatBlockCopy(NewFilename,SeparatorString);
  633.                         if (LeftHalfOfString != NIL)
  634.                             {
  635.                                 char*                            TotalString;
  636.  
  637.                                 TotalString = ConcatBlockCopy(LeftHalfOfString,LocalNameCopy);
  638.                                 if (TotalString != NIL)
  639.                                     {
  640.                                         char*                            NullTerminatedString;
  641.  
  642.                                         NullTerminatedString = BlockToStringCopy(TotalString);
  643.                                         if (NullTerminatedString != NIL)
  644.                                             {
  645.                                                 SetWindowName(Window->ScreenID,NullTerminatedString);
  646.                                                 ChangeItemName(Window->MyMenuItem,NullTerminatedString);
  647.                                                 ReleasePtr(NullTerminatedString);
  648.                                             }
  649.                                         ReleasePtr(TotalString);
  650.                                     }
  651.                                 ReleasePtr(LeftHalfOfString);
  652.                             }
  653.                         ReleasePtr(SeparatorString);
  654.                     }
  655.                 ReleasePtr(LocalNameCopy);
  656.             }
  657.     }
  658.  
  659.  
  660. /* update the title bar of the window even if the filename hasn't changed */
  661. void                                InstrWindowResetTitlebar(InstrWindowRec* Window)
  662.     {
  663.         char*                            DocumentName;
  664.  
  665.         CheckPtrExistence(Window);
  666.         DocumentName = GetCopyOfDocumentName(Window->MainWindow);
  667.         if (DocumentName != NIL)
  668.             {
  669.                 InstrWindowGlobalNameChange(Window,DocumentName);
  670.                 ReleasePtr(DocumentName);
  671.             }
  672.     }
  673.  
  674.  
  675. /* write back all modified data to the instrument object */
  676. MyBoolean                        InstrWindowWritebackModifiedData(InstrWindowRec* Window)
  677.     {
  678.         MyBoolean                    SuccessFlag = True;
  679.  
  680.         CheckPtrExistence(Window);
  681.  
  682.         /* save the name if it has been altered */
  683.         if (TextEditDoesItNeedToBeSaved(Window->NameEdit))
  684.             {
  685.                 char*                    NameTemp;
  686.  
  687.                 NameTemp = InstrWindowGetNameCopy(Window);
  688.                 if (NameTemp != NIL)
  689.                     {
  690.                         InstrObjectPutName(Window->InstrObj,NameTemp);
  691.                         TextEditHasBeenSaved(Window->NameEdit);
  692.                     }
  693.                  else
  694.                     {
  695.                         SuccessFlag = False;
  696.                     }
  697.             }
  698.  
  699.         /* save the body if it has been altered */
  700.         if (TextEditDoesItNeedToBeSaved(Window->BodyEdit))
  701.             {
  702.                 char*                            Temp;
  703.  
  704.                 Temp = InstrWindowGetDefinitionCopy(Window);
  705.                 if (Temp != NIL)
  706.                     {
  707.                         InstrObjectPutDefinition(Window->InstrObj,Temp);
  708.                         TextEditHasBeenSaved(Window->BodyEdit);
  709.                     }
  710.                  else
  711.                     {
  712.                         SuccessFlag = False;
  713.                     }
  714.             }
  715.  
  716.         return SuccessFlag;
  717.     }
  718.